home *** CD-ROM | disk | FTP | other *** search
/ DOpus Plus / DOpus Plus.iso / Tutorial / C Guide / Time_module / ModuleEntry.c < prev    next >
C/C++ Source or Header  |  1998-09-20  |  9KB  |  265 lines
  1.  
  2. /* ModuleEntry.c
  3.  
  4.    Of course you may do all your work here, but it is nicer for
  5.    overview, you do here only some simple stuff
  6.     
  7. */
  8.  
  9. #include "includes/Project.h"
  10.  
  11.  
  12. /* At first here you *must* declare your ModuleInfo structure */
  13.  
  14. ModuleInfo module_info =
  15. {
  16.     2,                      // version - your choice...
  17.     "time.module",          // module name  (case sensitive !)
  18.     "time.catalog",         // catalog name (case sensitive !)
  19.     MODULEF_CALL_STARTUP,   // flags
  20.     1,                      // number of functions
  21.     { 0, COMMAND_0, MSG_CLOCK_DESC, NULL, CMD_0_TEMPL }
  22. };
  23.  
  24. /* If you want to add more functions, set the number before and
  25.    declare ie. :
  26.    
  27. ModuleFunction module_func[1] =
  28. { 
  29.     { 1, COMMAND_1, NULL, FUNCF_PRIVATE, NULL }   
  30. };
  31.  
  32. */
  33.  
  34.  
  35. /* If you are a really nice one, you may add at the following string
  36.    a \0 before and after the string... (I am sooo lazy ;-) ) */
  37.    
  38. static char version[] = "$VER: " VERSION_STRING " " __AMIGADATE__;
  39.  
  40. /********************************************************************/
  41. // EXTERNALS
  42.  
  43. extern void Deteach( struct Screen *screen );
  44.  
  45. /********************************************************************/
  46. // GLOBALS AND LOCAL FUNCTIONS
  47.  
  48. IPCData *clock_ipc;
  49.  
  50. ULONG ScanSub( STRPTR template, STRPTR args, USHORT template_count );
  51. void PrepareClock( struct Screen *screen, char *args );
  52.  
  53. /********************************************************************/
  54. // OUR ENTRY
  55.  
  56. int __asm __saveds L_Module_Entry( register __a0 char *args,              
  57.                                    register __a1 struct Screen *screen,   
  58.                                    register __a2 IPCData *ipc,
  59.                                    register __a3 IPCData *main_ipc,
  60.                                    register __d0 ULONG mod_id,
  61.                                    register __d1 EXT_FUNC(func_callback) )
  62. {       
  63.       char buffer[4];
  64.          
  65.       switch( mod_id )
  66.         {
  67.            case FUNCID_STARTUP:
  68.                                  /* Check - Should we start ? - If yes, there must be */
  69.                                  /* our variable in ENV:dopus and must contain "1".   */
  70.                                  /* If not, we simply return at this stage. */
  71.                                  
  72.                                  if( GetVar(CLOCKSTARTVAR, buffer, 4, LV_VAR|GVF_GLOBAL_ONLY) < 1 ||
  73.                                       buffer[0] != '1' )
  74.                                  return 1;
  75.                                  
  76.                                  /* Give DOpus some time to go on, */
  77.                                  /* so we must later not wait...   */
  78.                                   
  79.                                  Delay( 300 );
  80.                        
  81.            case 0:               
  82.                                  /* we do the same in every case */
  83.                                  PrepareClock( screen, args );                                 
  84.                                  break;            
  85.         }
  86.       
  87.       /* Always modules should return 1 ... */   
  88.       return 1;
  89. }
  90.  
  91. /********************************************************************/
  92. /* This function does parse the arguments (, if there are some) and */
  93. /* launches the clock deteaching routine, if the clock is not       */
  94. /* already running. If the clock does run, it does pass the given   */
  95. /* arguments to it or even a zero command. So is later no different */
  96. /* code needed to take care of the arguments.                       */
  97. /********************************************************************/  
  98.  
  99. void PrepareClock( struct Screen *screen, char *args )
  100. {
  101.    ULONG command   = NULL, ctr;
  102.    FuncArgs *fargs = NULL;
  103.    CPrefsData *cp  = NULL;
  104.  
  105. /* Like you here see, you should always check if there are arguments  */
  106. /* before you try to parse them. ParseArgs() does not accept NULL !   */
  107.       
  108.    if( *args &&  (fargs = ParseArgs(CMD_0_TEMPL, args)) )
  109.      {
  110.         /* I use here AllocVec(), because I use later the data_free   */
  111.         /* element of IPC_Command()                                   */
  112.         
  113.         if( (cp = AllocVec(sizeof(CPrefsData), MEMF_CLEAR)) )
  114.           {
  115.              /* At first we make a note, what arguments are given     */
  116.              
  117.              for( ctr = 0; ctr <= CLOCKARG_COUNT; ctr++ )
  118.                   if( fargs->FA_Arguments[ctr] )
  119.                        command |= 1 << ctr;
  120.              
  121.              /* If a delay is given, we do it now and delete the bit  */
  122.              /* in command                                            */
  123.              
  124.              if( ARG_DELAY )
  125.                {
  126.                   Delay( *(ULONG *) ARG_DELAY );
  127.                   command ^= 1 << 2;
  128.                }
  129.              
  130.              /* Now we are ready to store all values step by step     */
  131.                           
  132.              if( ARG_FONT )
  133.                   strcpy( cp->fontname, (STRPTR) ARG_FONT );
  134.         
  135.              if( ARG_SIZE )
  136.                   cp->txtattr.ta_YSize = *(ULONG *) ARG_SIZE;
  137.                     
  138.              if( ARG_APEN )
  139.                   cp->ibox.Width       = *(ULONG *) ARG_APEN;
  140.                     
  141.              if( ARG_BPEN )
  142.                   cp->ibox.Height      = *(ULONG *) ARG_BPEN;
  143.                     
  144.              if( ARG_MODE )
  145.                {
  146.                   /* Mode has a subtemplate and must be parsed again */
  147.                   
  148.                   cp->txtattr.ta_Flags = ScanSub( MODE_TEMPL, (STRPTR) ARG_MODE, 4 );
  149.                                     
  150.                   if( cp->txtattr.ta_Flags & 1 << 0 )
  151.                        cp->txtattr.ta_Flags = 0;
  152.                   else
  153.                        cp->txtattr.ta_Flags >>= 1;
  154.                }
  155.                  
  156.              if( ARG_STYLE )
  157.                {
  158.                   cp->txtattr.ta_Style = ScanSub( STYLE_TEMPL, (STRPTR) ARG_STYLE, 4 );
  159.                   
  160.                   if( cp->txtattr.ta_Style & 1 << 0 )
  161.                        cp->txtattr.ta_Style = 0;
  162.                   else
  163.                        cp->txtattr.ta_Style >>= 1;          
  164.                }
  165.           
  166.              if( ARG_BORDER )
  167.                {
  168.                   if( ScanSub( ON_OFF_TEMPL, (STRPTR) ARG_BORDER, 8 ) < NO_CASE )
  169.                       command |= BORDER_ON;
  170.                   else
  171.                       command |= BORDER_OFF;                        
  172.                }
  173.             
  174.              if( ARG_PIC )
  175.                   strcpy( cp->picture, (STRPTR) ARG_PIC );
  176.                                                   
  177.              if( ARG_LEFT )
  178.                   cp->ibox.Left = *(ULONG *) ARG_LEFT;
  179.                               
  180.              if( ARG_TOP )
  181.                   cp->ibox.Top  = *(ULONG *) ARG_TOP;
  182.         
  183.              if( ARG_ALARM )
  184.                {
  185.                   /* If ScanSub() does return 0, we should have a time */
  186.                   /* as argument ( = else )                            */
  187.                   
  188.                   if( (ctr = ScanSub(ON_OFF_TEMPL, (STRPTR) ARG_ALARM, 8)) )
  189.                     {
  190.                        if( ctr < NO_CASE )
  191.                             command |= ALARM_ON;
  192.                        else
  193.                             command |= ALARM_OFF;
  194.                     }
  195.                   else
  196.                     {
  197.                        strcpy( cp->alarm, (STRPTR) ARG_ALARM );
  198.                        command |= ALARM_ON;
  199.                     }
  200.                }
  201.          
  202.              if( ARG_SOUND )
  203.                {
  204.                   if( ScanSub(ON_OFF_TEMPL, (STRPTR) ARG_SOUND, 8) < NO_CASE )
  205.                        command |= SOUND_ON;
  206.                   else
  207.                        command |= SOUND_OFF;
  208.                }
  209.           }
  210.      }
  211.     
  212.    if( !clock_ipc )
  213.      {
  214.         Deteach( screen );
  215.         while( !clock_ipc )
  216.                 Delay( 20 );
  217.      }
  218.      
  219.    IPC_Command( clock_ipc, command, NULL, NULL, cp, REPLY_NO_PORT );                                 
  220.         
  221.    if( fargs )
  222.         DisposeArgs( fargs );
  223.          
  224. }
  225.  
  226. /********************************************************************/
  227.  
  228. ULONG ScanSub( STRPTR template, STRPTR args, USHORT template_count )
  229. {
  230.       UBYTE     ctr;
  231.       ULONG     ret = NULL;
  232.       STRPTR    ptr;
  233.       FuncArgs *fargs;
  234.       
  235.       ptr = args;
  236.       
  237.       /* More than one argument should be added by the user with     */
  238.       /* a "|", but for parsing we need spaces. So we simply replace */
  239.       /* the "|" by spaces...                                        */ 
  240.                                 
  241.       while( *ptr )
  242.         {
  243.            if( *ptr == '|' )
  244.                *ptr =  ' ';
  245.            ptr++;
  246.         }
  247.         
  248.       /* Now we have a "normal" argument string and can parse it      */ 
  249.                     
  250.       if( (fargs = ParseArgs(template, args)) )
  251.         {
  252.            for( ctr = 0; ctr < template_count; ctr++ )
  253.                 if( fargs->FA_Arguments[ctr] )
  254.                      ret |= 1 << ctr;
  255.            
  256.            DisposeArgs( fargs );                     
  257.         }   
  258.       
  259.       return ret; 
  260. }
  261.  
  262. /********************************************************************/
  263.  
  264.  
  265.